# -*- coding: utf-8 -*-
from mod_log import logger
import math
import random
from legendaryPowerScript._lpcommon import apiUtil
from legendaryPowerScript._lpcommon.vector import Vector
import mod.server.extraServerApi as serverApi
def factoryCuboid(center, horizontalRadius, verticalRadius, down=True):
    # type: (Vector, float, float, bool) -> CuboidBoundingBox
    """
    创建一个立方体碰撞箱

    Args:
        center (Vector): 立方体的中心点坐标
        horizontalRadius (float): 立方体的水平半径
        verticalRadius (float): 立方体的垂直半径
        down (bool, optional): 是否向下延伸，默认为True

    Returns:
        CuboidBoundingBox: 创建的立方体碰撞箱对象
    """
    pass

def _getChunk(x, z=None):
    # type: (int, int, optional) -> tuple[int, int]
    """
    获取区块坐标

    Args:
        x (int): X坐标
        z (int, optional): Z坐标，默认为None

    Returns:
        tuple[int, int]: 区块坐标
    """
    return ()


def findBlockHit(start, end, step=.1, minY=None):
    # type: (Vector, Vector, float or None) -> Vector
    """
    查找射线与方块的碰撞点

    Args:
        start (Vector): 射线起始点坐标
        end (Vector): 射线终点坐标
        step (float or None, optional): 射线前进的步长，默认为0.1
        minY (float or None, optional): Y坐标的最小值，默认为None

    Returns:
        Vector or None: 碰撞点坐标，若无碰撞则返回None
    """
    pass

def findHitEntities(start, end, expand=False):
    # type: (Vector, Vector) -> list[tuple[Fighter, Vector, float]]
    """
    查找射线与实体的碰撞点

    Args:
        start (Vector): 射线起始点坐标
        end (Vector): 射线终点坐标
        expand (bool, optional): 是否扩展实体碰撞箱，默认为False

    Returns:
        list[tuple[Fighter, Vector, float]]: 碰撞的实体列表，每个元素为(Fighter, 碰撞点坐标, 到射线起始点的距离平方)的元组
    """
    pass

class SphereBoundingBox(object):
    # type: () -> None
    """
    表示一个球形边界框的类。

    Attributes:
        center (Vector): 球体的中心点坐标。
        radius (float): 球体的半径。
        chunks (list): 球体所在的区块列表。
        minRadius (float): 球体的最小半径。
        inactive (bool): 指示球体是否处于非活动状态。
    """
    self.center  = Vector()
    self.radius  = 0.0
    self.chunks  = []
    self.minRadius  = 0.0
    self.inactive  = False

    def findPlayersInside(self):
        # type: () -> list[Fighter]
        """
        查找球体内的玩家。

        Returns:
            list[Fighter]: 球体内的玩家对象列表。
        """
        pass

    def getChunks(self):
        # type: () -> list
        """
        获取球体所在的区块列表。

        Returns:
            list: 球体所在的区块坐标列表。
        """
        return []


    def getCenter(self):
        # type: () -> Vector
        """
        获取球体的中心点坐标。

        Returns:
            Vector: 球体的中心点坐标。
        """
        return Vector()


    def getRadius(self):
        # type: () -> float
        """
        获取球体的半径。

        Returns:
            float: 球体的半径。
        """
        return 0.0


    def findEntitiesInside(self):
        # type: () -> list[Fighter]
        """
        查找球体内的实体。

        Returns:
            list[Fighter]: 球体内的实体对象列表。
        """
        pass

    def removeAvoidZone(self):
        # type: () -> None
        """
        移除怪物AI的避让区域
        """
        pass

    def findSafeSpawnLocation(self):
        # type: () -> Vector
        """
        在球体内查找一个安全的生成位置。

        Returns:
            Vector: 安全生成位置的坐标，如果找不到合适的位置则返回None。
        """
        return Vector()


    def __contains__(self, item):
        # type: (Vector or CuboidBoundingBox or Fighter) -> bool
        """
        检查一个对象是否在球体内。

        Args:
            item (Vector or CuboidBoundingBox or Fighter): 需要检查的对象。

        Returns:
            bool: 如果对象在球体内则返回True，否则返回False。
        """
        return False


class CuboidBoundingBox(object):
    # type: () -> None
    """
    表示一个长方体碰撞箱的类。注意，此碰撞箱和原版的相同，即：不能旋转，三个轴永远与x,y,z轴平行。若需要可旋转的碰撞箱，请用OBB类

    Attributes:
        min (Vector): 碰撞箱的最小点坐标。
        max (Vector): 碰撞箱的最大点坐标。
        chunks: 碰撞箱所包含的区块。
        dimension (int): 碰撞箱的维度。
        inactive (bool): 碰撞箱是否是非活动状态。
    """
    self.min  = Vector()
    self.max  = Vector()
    self.dimension  = 0
    self.inactive  = False

    def getVolume(self):
        """
        计算碰撞箱的体积。
        Returns:
            float: 碰撞箱的体积。
        """
        pass

    def midPoint(self):
        # type: () -> Vector
        """
        计算碰撞箱的中心点。
        Returns:
            Vector: 碰撞箱的中心点坐标。
        """
        pass

    def __repr__(self):
        # type: () -> str
        """
        返回表示碰撞箱的字符串。

        Returns:
            str: 碰撞箱的字符串表示。
        """
        return ""


    def getCenter(self):
        # type: () -> Vector
        """
        获取碰撞箱的中心点。

        Returns:
            Vector: 碰撞箱的中心点坐标。
        """
        return Vector()


    def getRadius(self):
        # type: () -> float
        """
        计算碰撞箱的半径。

        Returns:
            float: 碰撞箱的半径。
        """
        return 0.0


    def intersects(self, other):
        # type: (Vector 或 CuboidBoundingBox) -> bool
        """
        判断碰撞箱是否与另一个对象相交。

        Args:
            other (Vector 或 CuboidBoundingBox): 要判断的对象。

        Returns:
            bool: 如果碰撞箱与对象相交，则为True；否则为False。
        """
        return False


    def __contains__(self, item):
        """
        判断碰撞箱是否包含指定的对象。

        Args:
            item (Vector 或 CuboidBoundingBox 或 Fighter): 要判断的对象。

        Returns:
            bool: 如果碰撞箱包含指定的对象，则为True；否则为False。
        """
        pass

    def expand(self, x, y, z):
        # type: (float, float, float) -> CuboidBoundingBox
        """
        将碰撞箱扩展一定的大小。

        Args:
            x (float): x方向的扩展量。
            y (float): y方向的扩展量。
            z (float): z方向的扩展量。

        Returns:
            CuboidBoundingBox: 扩展后的碰撞箱。

        """
        pass

    def randomPoint(self):
        # type: () -> Vector
        """
        在碰撞箱内随机生成一个点。

        Returns:
            Vector: 生成的随机点的坐标。

        """
        pass

    def calculateIntercept(self, vecA, vecB):
        # type: (Vector, Vector) -> Vector
        """
        计算从A发射到B的射线与碰撞箱的碰撞点

        Args:
            vecA (Vector): 发射点A
            vecB (Vector): 目标点B

        Returns:
            Vector: 碰撞点，若没碰撞则返回None
        """
        return Vector()


    def findEntitiesInside(self):
        # type: () -> list[Fighter]
        """
        查找在边界框内的实体列表

        Returns:
            list[Fighter]: 实体列表
        """
        pass

    def getChunks(self):
        # type: () -> list
        """
        获取边界框涉及的区块列表

        Returns:
            list: 区块列表
        """
        return []


    def removeAvoidZone(self):
        # type: () -> None
        """
        移除怪物AI的避让区域
        """
        pass

    def findPlayersInside(self):
        # type: () -> list[Fighter]
        """
        查找在边界框内的玩家列表

        Returns:
            list[Fighter]: 玩家列表
        """
        return []


    def getIntersectedBoundingbox(self, other):
        # type: (CuboidBoundingBox) -> CuboidBoundingBox
        """
        获取与另一个边界框相交的边界框

        Args:
            other (CuboidBoundingBox): 另一个边界框

        Returns:
            CuboidBoundingBox: 相交的边界框
        """
        return CuboidBoundingBox()


    def findSafeSpawnLocation(self, downToGround=True, checkLos=False, origin=None, brightness=None):
        # type: (bool, optional, bool, optional, Vector, optional, tuple[int, int], optional) -> Vector
        """
        在区域中寻找安全的生成点位置

        Args:
            downToGround (bool, optional): 是否向下搜索直到找到地面. Defaults to True.
            checkLos (bool, optional): 是否检查视线. Defaults to False.
            origin (Vector, optional): 搜索起点. Defaults to None.
            brightness (tuple[int, int], optional): 光照亮度范围. Defaults to None.

        Returns:
            Vector: 安全的生成点位置
        """
        return Vector()


    def toFloatTuple(self):
        # type: () -> tuple
        """
        将边界框的坐标转换为浮点元组

        Returns:
            tuple: 浮点元组
        """
        return ()


    def join(self, other):
        # type: (CuboidBoundingBox) -> None
        """
        将当前边界框与另一个边界框合并

        Args:
            other (CuboidBoundingBox): 另一个边界框
        """
        pass

